<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
<!-- vxworks.qdoc -->
  <title>Qt for VxWorks | Qt 5.14</title>
  <link rel="stylesheet" type="text/css" href="style/offline-simple.css" />
  <script type="text/javascript">
    document.getElementsByTagName("link").item(0).setAttribute("href", "style/offline.css");
    // loading style sheet breaks anchors that were jumped to before
    // so force jumping to anchor again
    setTimeout(function() {
        var anchor = location.hash;
        // need to jump to different anchor first (e.g. none)
        location.hash = "#";
        setTimeout(function() {
            location.hash = anchor;
        }, 0);
    }, 0);
  </script>
</head>
<body>
<div class="header" id="qtdocheader">
  <div class="main">
    <div class="main-rounded">
      <div class="navigationbar">
        <table><tr>
<td ><a href="index.html">Qt 5.14</a></td><td >Qt for VxWorks</td></tr></table><table class="buildversion"><tr>
<td id="buildversion" width="100%" align="right">Qt 5.14.2 Reference Documentation</td>
        </tr></table>
      </div>
    </div>
<div class="content">
<div class="line">
<div class="content mainContent">
<div class="sidebar">
<div class="toc">
<h3><a name="toc">Contents</a></h3>
<ul>
<li class="level1"><a href="#supported-architectures-and-vxworks-releases">Supported Architectures and VxWorks Releases</a></li>
<li class="level1"><a href="#qt-for-vxworks-source-package">Qt for VxWorks Source Package</a></li>
<li class="level1"><a href="#requirements-for-vxworks">Requirements for VxWorks</a></li>
<li class="level2"><a href="#qtwidget-applications">QtWidget Applications</a></li>
<li class="level2"><a href="#qt-quick-2-applications">Qt Quick 2 Applications</a></li>
<li class="level1"><a href="#supported-modules">Supported Modules</a></li>
<li class="level2"><a href="#limitations-for-essential-modules">Limitations for Essential modules</a></li>
<li class="level2"><a href="#supported-add-ons">Supported Add-ons</a></li>
<li class="level1"><a href="#platform-notes">Platform Notes</a></li>
<li class="level1"><a href="#configuring-for-a-specific-device">Configuring for a Specific Device</a></li>
<li class="level1"><a href="#building-and-installing-qt-5">Building and Installing Qt 5</a></li>
<li class="level1"><a href="#platform-plugins-for-vxworks-devices">Platform Plugins for VxWorks Devices</a></li>
<li class="level2"><a href="#eglfs">EGLFS</a></li>
<li class="level2"><a href="#qt-quick-scene-graph-rendering-thread">Qt Quick Scene Graph Rendering Thread</a></li>
<li class="level2"><a href="#vxworksfb">VxWorksFB</a></li>
<li class="level1"><a href="#input">Input</a></li>
<li class="level2"><a href="#input-on-eglfs-and-vxworksfb">Input on eglfs and vxworksfb</a></li>
<li class="level2"><a href="#mouse">Mouse</a></li>
<li class="level2"><a href="#keyboard">Keyboard</a></li>
<li class="level2"><a href="#touch">Touch</a></li>
<li class="level2"><a href="#debugging-input-devices">Debugging Input Devices</a></li>
<li class="level2"><a href="#using-custom-mouse-cursor-images">Using Custom Mouse Cursor Images</a></li>
<li class="level1"><a href="#qml-component-loader-thread">QML Component Loader Thread</a></li>
<li class="level1"><a href="#preventing-timeouts-in-qeventdispatcher">Preventing Timeouts in QEventDispatcher</a></li>
<li class="level1"><a href="#running-qt-applications">Running Qt Applications</a></li>
<li class="level1"><a href="#limitations">Limitations</a></li>
<li class="level2"><a href="#openssl-support">OpenSSL Support</a></li>
<li class="level2"><a href="#video-memory">Video Memory</a></li>
<li class="level2"><a href="#vxworksfb">vxworksfb</a></li>
</ul>
</div>
<div class="sidebar-content" id="sidebar-content"></div></div>
<h1 class="title">Qt for VxWorks</h1>
<span class="subtitle"></span>
<!-- $$$vxworks.html-description -->
<div class="descr"> <a name="details"></a>
<p>Qt for <a href="vxworks.html">VxWorks</a> is available only under a commercial license.</p>
<p>Contact The Qt Company for more information: <a href="https://www.qt.io/contact-us/">https://www.qt.io/contact-us/</a></p>
<a name="supported-architectures-and-vxworks-releases"></a>
<h2 id="supported-architectures-and-vxworks-releases">Supported Architectures and VxWorks Releases</h2>
<p>Qt 5.5 is currently tested and supported on <a href="vxworks.html">VxWorks</a> 7 release SR0480 2016-09-16. Supported architecture is ARM-v7.</p>
<p>If you are interested in later Qt releases, please <a href="https://www.qt.io/contact-us/">contact</a> Qt professional services.</p>
<a name="qt-for-vxworks-source-package"></a>
<h2 id="qt-for-vxworks-source-package">Qt for VxWorks Source Package</h2>
<p>Qt for <a href="vxworks.html">VxWorks</a> is delivered via the <a href="https://account.qt.io/">Qt Account</a>, under the name <b>Qt 5.5&#x2e;1</b> &gt; <b>Qt <a href="vxworks.html">VxWorks</a> Platform Source Package</b>.</p>
<a name="requirements-for-vxworks"></a>
<h2 id="requirements-for-vxworks">Requirements for VxWorks</h2>
<a name="qtwidget-applications"></a>
<h3 id="qtwidget-applications">QtWidget Applications</h3>
<ul>
<li>Framebuffer device (FBDEV)</li>
<li>Evdev support (compatibility mode)</li>
<li>POSIX support</li>
<li>C++11 support</li>
</ul>
<a name="qt-quick-2-applications"></a>
<h3 id="qt-quick-2-applications">Qt Quick 2 Applications</h3>
<p>All features which are required for QtWidget applications, and in addition the following:</p>
<ul>
<li>GPU device (GPUDEV) for OpenGL ES 2.0</li>
</ul>
<a name="supported-modules"></a>
<h2 id="supported-modules">Supported Modules</h2>
<p>Almost all essential <a href="qtmodules.html">Qt modules</a> and some add-on modules supported.</p>
<a name="limitations-for-essential-modules"></a>
<h3 id="limitations-for-essential-modules">Limitations for Essential modules</h3>
<div class="table"><table class="generic" width="80%">
 <thead><tr class="qt-style"><th >Qt Module</th><th >Supported Features</th><th >Notes</th></tr></thead>
<tr valign="top" class="odd"><td ><a href="../qtmultimedia/qtmultimedia-index.html">Qt Multimedia</a></td><td >Audio</td><td ><a href="../qtmultimedia/qml-qtmultimedia-soundeffect.html">SoundEffect</a>, <a href="../qtmultimedia/qsound.html">QSound</a>, <a href="../qtmultimedia/qsoundeffect.html">QSoundEffect</a> and <a href="../qtmultimedia/qaudiooutput.html">QAudioOutput</a></td></tr>
<tr valign="top" class="even"><td ><a href="../qtmultimedia/qtmultimediawidgets-index.html">Qt Multimedia Widgets</a></td><td >Not supported</td><td ></td></tr>
<tr valign="top" class="odd"><td >Qt <a href="../qtwebengine/qtwebengine-3rdparty-webkit.html">WebKit</a></td><td >Not supported</td><td ></td></tr>
<tr valign="top" class="even"><td >Qt <a href="../qtwebengine/qtwebengine-3rdparty-webkit.html">WebKit</a> Widgets</td><td >Not supported</td><td ></td></tr>
</table></div>
<a name="supported-add-ons"></a>
<h3 id="supported-add-ons">Supported Add-ons</h3>
<div class="table"><table class="generic" width="80%">
 <thead><tr class="qt-style"><th >Qt Add-on</th><th >Notes</th></tr></thead>
<tr valign="top" class="odd"><td ><a href="../qtcharts/qtcharts-index.html">Qt Charts</a></td><td >Version 2.0&#x2e;1</td></tr>
<tr valign="top" class="even"><td ><a href="../qtdatavisualization/qtdatavisualization-index.html">Qt Data Visualization</a></td><td >Version 1.2&#x2e;1</td></tr>
<tr valign="top" class="odd"><td ><a href="../qtvirtualkeyboard/qtvirtualkeyboard-index.html">Qt Virtual Keyboard</a></td><td >Version 2.0</td></tr>
<tr valign="top" class="even"><td ><a href="http://doc.qt.io/QtQuickCompiler">Qt Quick Compiler</a></td><td >Version 3.0</td></tr>
<tr valign="top" class="odd"><td ><a href="../qtconcurrent/qtconcurrent-index.html">Qt Concurrent</a></td><td ></td></tr>
<tr valign="top" class="even"><td ><a href="../qtgraphicaleffects/qtgraphicaleffects-index.html">Qt Graphical Effects</a></td><td ></td></tr>
<tr valign="top" class="odd"><td ><a href="license-changes.html#qt-image-formats">Qt Image Formats</a></td><td ></td></tr>
<tr valign="top" class="even"><td ><a href="../qtopengl/qtopengl-index.html">Qt OpenGL</a></td><td >Only OpenGL ES 2<p><b>Note: </b>Provided to ease porting from Qt 4.x&#x2e; Use the QOpenGL classes in <a href="../qtgui/qtgui-index.html">Qt GUI</a> for new code</p></td></tr>
<tr valign="top" class="odd"><td ><a href="../qtplatformheaders/qtplatformheaders-index.html">Qt Platform Headers</a></td><td ></td></tr>
<tr valign="top" class="even"><td ><a href="../qtsvg/qtsvg-index.html">Qt SVG</a></td><td ></td></tr>
<tr valign="top" class="odd"><td ><a href="../qtxmlpatterns/qtxmlpatterns-index.html">Qt XML Patterns</a></td><td ></td></tr>
</table></div>
<p><b>Note: </b>You can explicitly exclude unsupported or unused modules from the build via the -skip &lt;module&gt; option when running the configure tool.</p><a name="platform-notes"></a>
<h2 id="platform-notes">Platform Notes</h2>
<p>With the release of Qt 5.0, Qt no longer contains its own window system implementation: QWS is no longer a supported platform. For single-process use cases, the <a href="qpa.html">Qt Platform Abstraction</a> is a superior solution.</p>
<p>There are two platform plugins that are usable on <a href="vxworks.html">VxWorks</a>: EGLFS and <a href="vxworks.html#vxworksfb">VxWorksFB</a>. The availability of these plugins depends on the configuration of Qt. The default platform plugin is also device-specific. For instance, on many boards <code>eglfs</code> will be chosen as the default one. If the default is not suitable, the <code>QT_QPA_PLATFORM</code> environment variable parameter can be used to request another plugin. Alternatively, for quick tests, the <code>-platform</code> command-line option can be used with the same syntax.</p>
<a name="configuring-for-a-specific-device"></a>
<h2 id="configuring-for-a-specific-device">Configuring for a Specific Device</h2>
<p>Building Qt for a given device requires a toolchain and a sysroot. Additionally, some devices require vendor specific adaptation code for EGL and OpenGL ES 2.0 support. This is not relevant for non-accelerated platforms, for example the ones using the <a href="vxworks.html#vxworksfb">VxWorksFB</a> plugin, however neither OpenGL nor Qt Quick 2 will be functional in such a setup.</p>
<p>The directory <i>qtbase/mkspecs/devices</i> contains configuration and graphics adaptation code for a number of devices. For example, <code>vxworks-imx6</code> contains build settings, such as the optimal compiler and linker flags, for the <a href="http://en.wikipedia.org/wiki/I.MX#i.MX6x_series">Freescale iMX6 series</a>, and either an implementation of the eglfs hooks (vendor-specific adaptation code), or a reference to a suitable eglfs device integration plugin. The device is selected through the <a href="configure-options.html">configure</a> tool's <code>-device</code> parameter. The name that follows after this argument must, at least partially, match one of the subdirectories under <i>devices</i>.</p>
<p>Before running configure and building Qt 5 it is required to open <i><a href="vxworks.html">VxWorks</a> 7 Development Shell</i> in command prompt.</p>
<ul>
<li>Linux:<pre class="cpp plain">

  cd &lt;VxWorks 7 installation directory&gt;
  ./wrenv.sh -p vxworks-7

</pre>
</li>
<li>Windows:<pre class="cpp plain">

  cd &lt;VxWorks 7 installation directory&gt;
  wrenv -p vxworks-7

</pre>
</li>
</ul>
<p>Below is an example configuration for the BD-SL-i.MX6. For most <a href="vxworks.html">VxWorks</a> boards the configure command will look very similar. By default, Qt 5 is configured to use shared libraries. To build Qt 5 statically, add <code>-static</code> option for configure.</p>
<pre class="cpp plain">

  ./configure -commercial -confirm-license -device vxworks-imx6 -device-option CROSS_COMPILE=arm -prefix /sd1:1/qt5rtp -sysroot &lt;path_to_vxworks_vsb_dir&gt;/fsl_imx6_1_1_11_0_VSB -no-gcc-sysroot -extprefix &lt;path_to_host_dir&gt;/qt5rtp -hostprefix &lt;path_to_host_dir&gt;/qt5rtp -no-openssl -nomake tools -nomake examples

</pre>
<p>The most important parameters are <code>-device</code>, <code>-device-option</code> CROSS_COMPILE=&lt;arch&gt;, <code>-sysroot</code> and <code>-no-gcc-sysroot</code>. By specifying <code>-sysroot</code>, the include files and libraries used by <code>configure</code>'s feature detection tests, as well as Qt itself, will be taken from the specified location, instead of the host PC's standard locations. This means that installing development packages on the host machine has no relevance. Instead, the headers and the libraries for the target architecture (e.g&#x2e; ARM) have to be present in the sysroot.</p>
<p>It is recommended to build Qt 5 using a <i>shadow build</i>. See <a href="configure-options.html">Qt Configure Options</a> for more information.</p>
<a name="building-and-installing-qt-5"></a>
<h2 id="building-and-installing-qt-5">Building and Installing Qt 5</h2>
<pre class="cpp plain">

  make -j&lt;N&gt;
  make install

</pre>
<a name="platform-plugins-for-vxworks-devices"></a>
<h2 id="platform-plugins-for-vxworks-devices">Platform Plugins for VxWorks Devices</h2>
<a name="eglfs"></a>
<h3 id="eglfs">EGLFS</h3>
<p><a href="http://www.khronos.org/egl">EGL</a> is an interface between OpenGL and the native windowing system. Qt can use EGL for context and surface management, however the API contains no platform specifics: The creation of a <i>native window</i> (which will not necessarily be an actual window on the screen) must still be done by platform-specific means. Hence the need for the board or GPU specific adaptation code. Such adaptations are provided either as <i>eglfs hooks</i>, a single source file compiled in to the platform plugin, or as dynamically loaded <i>EGL device integration</i> plugins.</p>
<p>EGLFS is a platform plugin for running Qt 5 applications on top of EGL and OpenGL ES 2.0 without an actual windowing system (like X11 or Wayland). In addition to Qt Quick 2 and native OpenGL applications it supports software-rendered windows (for example <a href="../qtwidgets/qwidget.html">QWidget</a>) too. In the latter case the widgets' contents are rendered using the CPU into images which are then uploaded into textures and composited by the plugin.</p>
<p>This is the recommended plugin for modern <a href="vxworks.html">VxWorks</a> devices that include a GPU.</p>
<p>EGLFS forces the first top-level window (be it either a <a href="../qtwidgets/qwidget.html">QWidget</a> or a <a href="../qtquick/qquickview.html">QQuickView</a>) to become fullscreen. This window is also chosen to be the <i>root</i> widget window into which all other top-level widgets (for example dialogs, popup menus or combobox dropdowns) are composited. This is necessary because with EGLFS there is always exactly one native window and EGL window surface, and these belong to the widget or window that is created first. This approach works well when there is a main window that exists for the entire lifetime of the application and all other widgets are either non top-levels or are created afterwards, once the main window is shown.</p>
<p>There are further restrictions for OpenGL-based windows. As of Qt 5.3, eglfs supports a single, fullscreen GL window (for example, an OpenGL-based <a href="../qtgui/qwindow.html">QWindow</a>, a <a href="../qtquick/qquickview.html">QQuickView</a> or a QGLWidget). Opening additional OpenGL windows or mixing such windows with <a href="../qtwidgets/qwidget.html">QWidget</a>-based content is not supported and will terminate the application with an error message.</p>
<p>If necessary, eglfs can be configured via environment variables:</p>
<ul>
<li><code>QT_QPA_EGLFS_FB</code> - Overrides the framebuffer device. The default is <code>/dev/fb0</code>. On most embedded platforms this is not very relevant because the framebuffer is used only for querying settings like the display dimensions. On certain devices however this parameter provides the ability to specify which display to use in multiple display setups, similarly to the <code>fb</code> parameter in <a href="vxworks.html#vxworksfb">VxWorksFB</a>.</li>
<li><code>QT_QPA_EGLFS_WIDTH</code> and <code>QT_QPA_EGLFS_HEIGHT</code> - Contain the screen width and height in pixels. While eglfs will try to determine the dimensions from the framebuffer device <i>/dev/fb0</i>, this will not always work and manually specifying the sizes may become necessary.</li>
<li><code>QT_QPA_EGLFS_PHYSICAL_WIDTH</code> and <code>QT_QPA_EGLFS_PHYSICAL_HEIGHT</code> - Physical screen width and height in millimeters. On platforms where the framebuffer device <i>/dev/fb0</i> is not available or the query is not successful, the values are calculated based on a default DPI of 100. This variable can be used to override any such defaults.</li>
<li><code>QT_QPA_EGLFS_DEPTH</code> - Overrides the color depth for the screen. On platforms where the framebuffer device <i>/dev/fb0</i> is not available or the query is not successful, the default of 32 is used. This variable can be used to override any such defaults. Note that this affects only the color depth value reported by <a href="../qtgui/qscreen.html">QScreen</a>. It has no connection to EGL configurations and the color depth used for OpenGL rendering.</li>
<li><code>QT_QPA_EGLFS_SWAPINTERVAL</code> - By default a swap interval of <code>1</code> will be requested. This enables synchronizing to the displays vertical refresh. The value can be overridden with this environment variable. For instance, passing 0 will disable blocking on swap, resulting in running as fast as possible without any synchronization.</li>
<li><code>QT_QPA_EGLFS_FORCE888</code> - When set, the red, green and blue color channel sizes are ignored whenever creating a new context, window or offscreen surface. Instead, the plugin will request a configuration with 8 bits per channel. This can be helpful on devices where configurations with less than 32 or 24 bits per pixel are chosen by default but are known not to be suitable, for example, due to banding effects. Instead of changing all the applications, this variable provides an easier shortcut to force 24/32 bpp configurations for a given device.</li>
<li><code>QT_QPA_EGLFS_DEBUG</code> - When set, some debugging information is printed on the debug output. For example, the input <a href="../qtgui/qsurfaceformat.html">QSurfaceFormat</a> and the properties of the chosen EGL configuration are printed whenever creating a new context. Together with Qt Quick's <code>QSG_INFO</code> variable, this can provide useful information for troubleshooting issues related to the EGL configuration.</li>
<li><code>QT_QPA_EGLFS_INTEGRATION</code> - In addition to the compiled-in <i>hooks</i>, it is also possible to provide device or vendor-specific adaptation in the form of dynamically loaded plugins. This environment variable enforces a specific plugin. For example, setting it to <i>eglfs_kms</i> will use the KMS/DRM backend. This is only an option when no static, compiled-in hooks were specified in the device makespecs. In practice the traditional compiled-in hooks are rarely used, almost all backends are now migrated to plugins. The device makespecs still contain a relevant <code>EGLFS_DEVICE_INTEGRATION</code> entry: the name of the preferred backend for that particular device. This is optional, but very useful to avoid the need to set this environment variable in case there are more than one plugins present in the target system. In a desktop environment the KMS or the X11 backends are prioritized, depending on the presence of the <code>DISPLAY</code> environment variable.</li>
</ul>
<p>In addition to <code>QT_QPA_EGLFS_DEBUG</code>, eglfs also supports the more modern categorized logging system of Qt. The following logging categories are available:</p>
<ul>
<li><code>qt.qpa.egldeviceintegration</code> – Enables logging for dynamically loaded backends. Very useful to check what backend is in use.</li>
<li><code>qt.qpa.input</code> – Enables debug output from the evdev input handler. Very useful to check if a given input device was correctly recognized and opened.</li>
</ul>
<a name="qt-quick-scene-graph-rendering-thread"></a>
<h3 id="qt-quick-scene-graph-rendering-thread">Qt Quick Scene Graph Rendering Thread</h3>
<p>The scene graph is a graphical representation of the Item scene. It can be thought of as a graphical deep copy, an independent structure that contains enough information to render all the items.</p>
<p>On many platforms, the <a href="topics-graphics.html#qt-quick-scene-graph">scene graph</a> will even be rendered on a dedicated render thread while the GUI thread is preparing the next frame's state.</p>
<p>In some cases when application is complex e.g&#x2e; it's scene graph contains lot's of Items, scene graph can consume more stack memory than what is available by default for the render thread. Default stack memory size is 64KB. Using the environment variable QSG_RENDERTHREAD_STACK_SIZE, it is possible to increase the stack size available for the scene graph render thread.</p>
<a name="vxworksfb"></a>
<h3 id="vxworksfb">VxWorksFB</h3>
<p>This plugin writes directly to the framebuffer. Only software-rendered content is supported. Note that on some setups the display performance is expected to be limited.</p>
<p>The <code>vxworksfb</code> plugin allows specifying additional settings by passing them in the <code>QT_QPA_PLATFORM</code> environment variable or <code>-platform</code> command-line option. For example, <code>QT_QPA_PLATFORM=vxworksfb:fb=/dev/fb1</code> specifies that the framebuffer device <code>/dev/fb1</code> should be used instead of the default <code>fb0</code>. Multiple settings can be specfified by separating them with a colon.</p>
<ul>
<li><code>fb=/dev/fbN</code> - Specifies the framebuffer devices. On multiple display setups this will typically allow running the application on different displays. For the time being there is no way to use multiple framebuffers from one Qt application.</li>
<li><code>size=</code><i>&lt;width&gt;</i><code>x</code><i>&lt;height&gt;</i> - Specifies the screen size in pixels. The plugin will try to query the display dimensions, both physical and logical, from the framebuffer device. This may not always lead to proper results however, and therefore it may become necessary to explicitly specify the values.</li>
<li><code>mmSize=</code><i>&lt;width&gt;</i><code>x</code><i>&lt;height&gt;</i> - Physical width and height in millimeters.</li>
<li><code>offset=</code><i>&lt;width&gt;</i><code>x</code><i>&lt;height&gt;</i> - Offset in pixels specifying the top-left corner of the screen. The default position is at <code>(0, 0)</code>.</li>
</ul>
<a name="input"></a>
<h2 id="input">Input</h2>
<p>When no windowing system is present, the mouse, keyboard and touch input are read directly via <code>evdev</code>. Note that this requires that devices nodes <code>/input/event*</code> are readable by the user. eglfs and vxworksfb has all the evdev input handling code built-in.</p>
<a name="input-on-eglfs-and-vxworksfb"></a>
<h3 id="input-on-eglfs-and-vxworksfb">Input on eglfs and vxworksfb</h3>
<p>Parameters like the device node name can be set in the environment variables <code>QT_QPA_EVDEV_MOUSE_PARAMETERS</code>, <code>QT_QPA_EVDEV_KEYBOARD_PARAMETERS</code> and <code>QT_QPA_EVDEV_TOUCHSCREEN_PARAMETERS</code>. Additionally, the built-in input handlers can be disabled by setting <code>QT_QPA_EGLFS_DISABLE_INPUT</code> or <code>QT_QPA_FB_DISABLE_INPUT</code> to <code>1</code>. On some touch screens the coordinates will need to be rotated. This can be enabled by setting <code>QT_QPA_EVDEV_TOUCHSCREEN_PARAMETERS</code> to <code>rotate=180</code>.</p>
<a name="mouse"></a>
<h3 id="mouse">Mouse</h3>
<p>The mouse cursor will show up whenever <code>QT_QPA_EGLFS_HIDECURSOR</code> (for eglfs) or <code>QT_QPA_FB_HIDECURSOR</code> (for vxworksfb) is not set, the mouse cursor will always show up unless explicitly disabled via the environment variable.</p>
<p>Hot plugging is not supported.</p>
<a name="keyboard"></a>
<h3 id="keyboard">Keyboard</h3>
<p>The evdev keyboard handler supports the following extra parameters:</p>
<ul>
<li><code>/input/..&#x2e;</code> - Specifies the name of the input device. When not given, Qt will look for a suitable device by walking through the available nodes.</li>
</ul>
<p>If the default, built-in keymap is not sufficient, a different one can be specified either via the <code>keymap</code> parameter or by using the eglfs-specific <a href="../qtplatformheaders/qeglfsfunctions.html#loadKeymap">loadKeymap()</a> function. The latter allows switching the keymap at runtime. Note however that this requires using eglfs' built-in keyboard handler; it is not supported when the keyboard handler is loaded via the <code>-plugin</code> command-line parameter.</p>
<a name="touch"></a>
<h3 id="touch">Touch</h3>
<p>Both single and multitouch devices are supported and require that <a href="vxworks.html">VxWorks</a> has been properly configured to support touch devices.</p>
<a name="debugging-input-devices"></a>
<h3 id="debugging-input-devices">Debugging Input Devices</h3>
<p>It is possible to print some information to the debug output by enabling the <code>qt.qpa.input</code> logging rule, for example by setting the <code>QT_LOGGING_RULES</code> environment variable to <code>qt.qpa.input=true</code>. This is useful for detecting which device is being used, or to troubleshoot device discovery issues.</p>
<a name="using-custom-mouse-cursor-images"></a>
<h3 id="using-custom-mouse-cursor-images">Using Custom Mouse Cursor Images</h3>
<p>eglfs comes with its own set of 32x32 sized mouse cursor images. If these are not sufficient, a custom cursor atlas can be provided by setting the <code>QT_QPA_EGLFS_CURSOR</code> environment variable to the name of a JSON file. The file can also be embedded into the application via Qt's resource system.</p>
<p>For example, an embedded cursor atlas with 8 cursor images per row can be specified like the following:</p>
<pre class="cpp plain">

  {
    &quot;image&quot;: &quot;:/cursor-atlas.png&quot;,
    &quot;cursorsPerRow&quot;: 8,
    &quot;hotSpots&quot;: [
        [7, 2],
        [12, 3],
        [12, 12],
        ..&#x2e;
    ]
  }

</pre>
<p>Note that the images are expected to be tightly packed in the atlas: the width and height of the cursors are decided based on the total image size and the <code>cursorsPerRow</code> setting. Atlases have to provide an image for all the supported cursors.</p>
<a name="qml-component-loader-thread"></a>
<h2 id="qml-component-loader-thread">QML Component Loader Thread</h2>
<p>In some cases, a complex application (for example, using a lot of custom QML components) may cause the QML loader thread to consume stack memory more than the 32 KB available by default. Using the environment variable <code>QML_LOADERTHREAD_STACK_SIZE</code>, it is possible to increase the stack size available for the QML loader thread.</p>
<a name="preventing-timeouts-in-qeventdispatcher"></a>
<h2 id="preventing-timeouts-in-qeventdispatcher">Preventing Timeouts in QEventDispatcher</h2>
<p>Default system clock rate (SYS_CLK_RATE) for <a href="vxworks.html">VxWorks</a> 7 is 1/60s or ~16,67ms. In some cases this may cause a drop in the application frame rate; in QEventDispatcher, the select function is blocking for the entire system clock interval because a timeout is used. By defining an environment variable <code>QT_FORCE_SELECT_NOTIMEOUT=1</code>, the select function returns immediately if no new events are available and the resolution of the system clock is higher than 10ms, which is true with default value.</p>
<a name="running-qt-applications"></a>
<h2 id="running-qt-applications">Running Qt Applications</h2>
<p>Following example shows how to start an application when Qt 5 is built using shared libraries. With a statically build Qt 5, there is no need to use the LD_LIBRARY_PATH environment variable. This variable is only needed to point the location of <a href="vxworks.html">VxWorks</a> shared libraries (for example libc and OpenGL ES 2.0). It is not needed for Qt 5 shared libraries.</p>
<pre class="cpp plain">

  putenv &quot;LD_LIBRARY_PATH=/sd0:1/lib&quot;
  cd &quot;/sd0:1&quot;
  rtpSp(&quot;&lt;Qt5_app&gt;&quot;, 200, 0x100000, 0, 0x01000000)

</pre>
<a name="limitations"></a>
<h2 id="limitations">Limitations</h2>
<a name="openssl-support"></a>
<h3 id="openssl-support">OpenSSL Support</h3>
<p>Qt 5 does not support OpenSSL for <a href="vxworks.html">VxWorks</a> as it does not support using OpenSSL in RTP mode.</p>
<a name="video-memory"></a>
<h3 id="video-memory">Video Memory</h3>
<p>Systems with a fixed amount of dedicated video memory may need extra care before running Qt application based on Qt Quick or classes like <a href="../qtwidgets/qopenglwidget.html">QOpenGLWidget</a>. The default setting may be insufficient for such applications, especially when they are displayed on a high resolution (for example, full HD) screen. In this case they may start failing in unexpected ways. It is therefore recommended to ensure that there is at least 128 MB of GPU memory available. For systems that do not have a fixed amount of memory reserved for the GPU this is not an issue.</p>
<a name="vxworksfb"></a>
<h3 id="vxworksfb">vxworksfb</h3>
<p>Use the <code>fb</code> plugin parameter to specify the framebuffer device to use.</p>
</div>
<!-- @@@vxworks.html -->
        </div>
       </div>
   </div>
   </div>
</div>
<div class="footer">
   <p>
   <acronym title="Copyright">&copy;</acronym> 2020 The Qt Company Ltd.
   Documentation contributions included herein are the copyrights of
   their respective owners.<br/>    The documentation provided herein is licensed under the terms of the    <a href="http://www.gnu.org/licenses/fdl.html">GNU Free Documentation    License version 1.3</a> as published by the Free Software Foundation.<br/>    Qt and respective logos are trademarks of The Qt Company Ltd.     in Finland and/or other countries worldwide. All other trademarks are property
   of their respective owners. </p>
</div>
</body>
</html>
